home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / os.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  14KB  |  620 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import sys
  5. import errno
  6. _names = sys.builtin_module_names
  7. __all__ = [
  8.     'altsep',
  9.     'curdir',
  10.     'pardir',
  11.     'sep',
  12.     'pathsep',
  13.     'linesep',
  14.     'defpath',
  15.     'name',
  16.     'path',
  17.     'devnull',
  18.     'SEEK_SET',
  19.     'SEEK_CUR',
  20.     'SEEK_END']
  21.  
  22. def _get_exports_list(module):
  23.     
  24.     try:
  25.         return list(module.__all__)
  26.     except AttributeError:
  27.         return _[1]
  28.     except:
  29.         []
  30.  
  31.  
  32. if 'posix' in _names:
  33.     name = 'posix'
  34.     linesep = '\n'
  35.     from posix import *
  36.     
  37.     try:
  38.         from posix import _exit
  39.     except ImportError:
  40.         pass
  41.  
  42.     import posixpath as path
  43.     import posix
  44.     __all__.extend(_get_exports_list(posix))
  45.     del posix
  46. elif 'nt' in _names:
  47.     name = 'nt'
  48.     linesep = '\r\n'
  49.     from nt import *
  50.     
  51.     try:
  52.         from nt import _exit
  53.     except ImportError:
  54.         pass
  55.  
  56.     import ntpath as path
  57.     import nt
  58.     __all__.extend(_get_exports_list(nt))
  59.     del nt
  60. elif 'os2' in _names:
  61.     name = 'os2'
  62.     linesep = '\r\n'
  63.     from os2 import *
  64.     
  65.     try:
  66.         from os2 import _exit
  67.     except ImportError:
  68.         pass
  69.  
  70.     if sys.version.find('EMX GCC') == -1:
  71.         import ntpath as path
  72.     else:
  73.         import os2emxpath as path
  74.         from _emx_link import link
  75.     import os2
  76.     __all__.extend(_get_exports_list(os2))
  77.     del os2
  78. elif 'mac' in _names:
  79.     name = 'mac'
  80.     linesep = '\r'
  81.     from mac import *
  82.     
  83.     try:
  84.         from mac import _exit
  85.     except ImportError:
  86.         pass
  87.  
  88.     import macpath as path
  89.     import mac
  90.     __all__.extend(_get_exports_list(mac))
  91.     del mac
  92. elif 'ce' in _names:
  93.     name = 'ce'
  94.     linesep = '\r\n'
  95.     from ce import *
  96.     
  97.     try:
  98.         from ce import _exit
  99.     except ImportError:
  100.         pass
  101.  
  102.     import ntpath as path
  103.     import ce
  104.     __all__.extend(_get_exports_list(ce))
  105.     del ce
  106. elif 'riscos' in _names:
  107.     name = 'riscos'
  108.     linesep = '\n'
  109.     from riscos import *
  110.     
  111.     try:
  112.         from riscos import _exit
  113.     except ImportError:
  114.         pass
  115.  
  116.     import riscospath as path
  117.     import riscos
  118.     __all__.extend(_get_exports_list(riscos))
  119.     del riscos
  120. else:
  121.     raise ImportError, 'no os specific module found'
  122. sys.modules['os.path'] = path
  123. from os.path import curdir, pardir, sep, pathsep, defpath, extsep, altsep, devnull
  124. del _names
  125. SEEK_SET = 0
  126. SEEK_CUR = 1
  127. SEEK_END = 2
  128.  
  129. def makedirs(name, mode = 511):
  130.     (head, tail) = path.split(name)
  131.     if not tail:
  132.         (head, tail) = path.split(head)
  133.     
  134.     if head and tail and not path.exists(head):
  135.         
  136.         try:
  137.             makedirs(head, mode)
  138.         except OSError:
  139.             e = None
  140.             if e.errno != errno.EEXIST:
  141.                 raise 
  142.             
  143.         except:
  144.             e.errno != errno.EEXIST
  145.  
  146.         if tail == curdir:
  147.             return None
  148.         
  149.     
  150.     mkdir(name, mode)
  151.  
  152.  
  153. def removedirs(name):
  154.     rmdir(name)
  155.     (head, tail) = path.split(name)
  156.     if not tail:
  157.         (head, tail) = path.split(head)
  158.     
  159.     while head and tail:
  160.         
  161.         try:
  162.             rmdir(head)
  163.         except error:
  164.             break
  165.  
  166.         (head, tail) = path.split(head)
  167.  
  168.  
  169. def renames(old, new):
  170.     (head, tail) = path.split(new)
  171.     if head and tail and not path.exists(head):
  172.         makedirs(head)
  173.     
  174.     rename(old, new)
  175.     (head, tail) = path.split(old)
  176.     if head and tail:
  177.         
  178.         try:
  179.             removedirs(head)
  180.         except error:
  181.             pass
  182.         except:
  183.             None<EXCEPTION MATCH>error
  184.         
  185.  
  186.     None<EXCEPTION MATCH>error
  187.  
  188. __all__.extend([
  189.     'makedirs',
  190.     'removedirs',
  191.     'renames'])
  192.  
  193. def walk(top, topdown = True, onerror = None):
  194.     join = join
  195.     isdir = isdir
  196.     islink = islink
  197.     import os.path
  198.     
  199.     try:
  200.         names = listdir(top)
  201.     except error:
  202.         err = None
  203.         if onerror is not None:
  204.             onerror(err)
  205.         
  206.         return None
  207.  
  208.     dirs = []
  209.     nondirs = []
  210.     for name in names:
  211.         if isdir(join(top, name)):
  212.             dirs.append(name)
  213.             continue
  214.         nondirs.append(name)
  215.     
  216.     if topdown:
  217.         yield (top, dirs, nondirs)
  218.     
  219.     for name in dirs:
  220.         path = join(top, name)
  221.         if not islink(path):
  222.             for x in walk(path, topdown, onerror):
  223.                 yield x
  224.             
  225.     
  226.     if not topdown:
  227.         yield (top, dirs, nondirs)
  228.     
  229.  
  230. __all__.append('walk')
  231.  
  232. try:
  233.     environ
  234. except NameError:
  235.     environ = { }
  236.  
  237.  
  238. def execl(file, *args):
  239.     execv(file, args)
  240.  
  241.  
  242. def execle(file, *args):
  243.     env = args[-1]
  244.     execve(file, args[:-1], env)
  245.  
  246.  
  247. def execlp(file, *args):
  248.     execvp(file, args)
  249.  
  250.  
  251. def execlpe(file, *args):
  252.     env = args[-1]
  253.     execvpe(file, args[:-1], env)
  254.  
  255.  
  256. def execvp(file, args):
  257.     _execvpe(file, args)
  258.  
  259.  
  260. def execvpe(file, args, env):
  261.     _execvpe(file, args, env)
  262.  
  263. __all__.extend([
  264.     'execl',
  265.     'execle',
  266.     'execlp',
  267.     'execlpe',
  268.     'execvp',
  269.     'execvpe'])
  270.  
  271. def _execvpe(file, args, env = None):
  272.     if env is not None:
  273.         func = execve
  274.         argrest = (args, env)
  275.     else:
  276.         func = execv
  277.         argrest = (args,)
  278.         env = environ
  279.     (head, tail) = path.split(file)
  280.     if head:
  281.         func(file, *argrest)
  282.         return None
  283.     
  284.     if 'PATH' in env:
  285.         envpath = env['PATH']
  286.     else:
  287.         envpath = defpath
  288.     PATH = envpath.split(pathsep)
  289.     saved_exc = None
  290.     saved_tb = None
  291.     for dir in PATH:
  292.         fullname = path.join(dir, file)
  293.         
  294.         try:
  295.             func(fullname, *argrest)
  296.         continue
  297.         except error:
  298.             e = None
  299.             tb = sys.exc_info()[2]
  300.             if e.errno != errno.ENOENT and e.errno != errno.ENOTDIR and saved_exc is None:
  301.                 saved_exc = e
  302.                 saved_tb = tb
  303.             
  304.             saved_exc is None
  305.         
  306.  
  307.     
  308.     if saved_exc:
  309.         raise error, saved_exc, saved_tb
  310.     
  311.     raise error, e, tb
  312.  
  313.  
  314. try:
  315.     putenv
  316. except NameError:
  317.     pass
  318.  
  319. import UserDict
  320. if name in ('os2', 'nt'):
  321.     
  322.     def unsetenv(key):
  323.         putenv(key, '')
  324.  
  325.  
  326. if name == 'riscos':
  327.     from riscosenviron import _Environ
  328. elif name in ('os2', 'nt'):
  329.     
  330.     class _Environ(UserDict.IterableUserDict):
  331.         
  332.         def __init__(self, environ):
  333.             UserDict.UserDict.__init__(self)
  334.             data = self.data
  335.             for k, v in environ.items():
  336.                 data[k.upper()] = v
  337.             
  338.  
  339.         
  340.         def __setitem__(self, key, item):
  341.             putenv(key, item)
  342.             self.data[key.upper()] = item
  343.  
  344.         
  345.         def __getitem__(self, key):
  346.             return self.data[key.upper()]
  347.  
  348.         
  349.         try:
  350.             unsetenv
  351.         except NameError:
  352.             
  353.             def __delitem__(self, key):
  354.                 del self.data[key.upper()]
  355.  
  356.  
  357.         
  358.         def __delitem__(self, key):
  359.             unsetenv(key)
  360.             del self.data[key.upper()]
  361.  
  362.         
  363.         def has_key(self, key):
  364.             return key.upper() in self.data
  365.  
  366.         
  367.         def __contains__(self, key):
  368.             return key.upper() in self.data
  369.  
  370.         
  371.         def get(self, key, failobj = None):
  372.             return self.data.get(key.upper(), failobj)
  373.  
  374.         
  375.         def update(self, dict = None, **kwargs):
  376.             if dict:
  377.                 
  378.                 try:
  379.                     keys = dict.keys()
  380.                 except AttributeError:
  381.                     for k, v in dict:
  382.                         self[k] = v
  383.                     
  384.  
  385.                 for k in keys:
  386.                     self[k] = dict[k]
  387.                 
  388.             
  389.             if kwargs:
  390.                 self.update(kwargs)
  391.             
  392.  
  393.         
  394.         def copy(self):
  395.             return dict(self)
  396.  
  397.  
  398. else:
  399.     
  400.     class _Environ(UserDict.IterableUserDict):
  401.         
  402.         def __init__(self, environ):
  403.             UserDict.UserDict.__init__(self)
  404.             self.data = environ
  405.  
  406.         
  407.         def __setitem__(self, key, item):
  408.             putenv(key, item)
  409.             self.data[key] = item
  410.  
  411.         
  412.         def update(self, dict = None, **kwargs):
  413.             if dict:
  414.                 
  415.                 try:
  416.                     keys = dict.keys()
  417.                 except AttributeError:
  418.                     for k, v in dict:
  419.                         self[k] = v
  420.                     
  421.  
  422.                 for k in keys:
  423.                     self[k] = dict[k]
  424.                 
  425.             
  426.             if kwargs:
  427.                 self.update(kwargs)
  428.             
  429.  
  430.         
  431.         try:
  432.             unsetenv
  433.         except NameError:
  434.             pass
  435.  
  436.         
  437.         def __delitem__(self, key):
  438.             unsetenv(key)
  439.             del self.data[key]
  440.  
  441.         
  442.         def copy(self):
  443.             return dict(self)
  444.  
  445.  
  446. environ = _Environ(environ)
  447.  
  448. def getenv(key, default = None):
  449.     return environ.get(key, default)
  450.  
  451. __all__.append('getenv')
  452.  
  453. def _exists(name):
  454.     
  455.     try:
  456.         eval(name)
  457.         return True
  458.     except NameError:
  459.         return False
  460.  
  461.  
  462. if _exists('fork') and not _exists('spawnv') and _exists('execv'):
  463.     P_WAIT = 0
  464.     P_NOWAIT = P_NOWAITO = 1
  465.     
  466.     def _spawnvef(mode, file, args, env, func):
  467.         pid = fork()
  468.         if not pid:
  469.             
  470.             try:
  471.                 if env is None:
  472.                     func(file, args)
  473.                 else:
  474.                     func(file, args, env)
  475.             _exit(127)
  476.  
  477.         elif mode == P_NOWAIT:
  478.             return pid
  479.         
  480.         while None:
  481.             (wpid, sts) = waitpid(pid, 0)
  482.             if WIFSTOPPED(sts):
  483.                 continue
  484.                 continue
  485.             if WIFSIGNALED(sts):
  486.                 return -WTERMSIG(sts)
  487.                 continue
  488.             if WIFEXITED(sts):
  489.                 return WEXITSTATUS(sts)
  490.                 continue
  491.             raise error, 'Not stopped, signaled or exited???'
  492.             continue
  493.             return None
  494.  
  495.     
  496.     def spawnv(mode, file, args):
  497.         return _spawnvef(mode, file, args, None, execv)
  498.  
  499.     
  500.     def spawnve(mode, file, args, env):
  501.         return _spawnvef(mode, file, args, env, execve)
  502.  
  503.     
  504.     def spawnvp(mode, file, args):
  505.         return _spawnvef(mode, file, args, None, execvp)
  506.  
  507.     
  508.     def spawnvpe(mode, file, args, env):
  509.         return _spawnvef(mode, file, args, env, execvpe)
  510.  
  511.  
  512. if _exists('spawnv'):
  513.     
  514.     def spawnl(mode, file, *args):
  515.         return spawnv(mode, file, args)
  516.  
  517.     
  518.     def spawnle(mode, file, *args):
  519.         env = args[-1]
  520.         return spawnve(mode, file, args[:-1], env)
  521.  
  522.     __all__.extend([
  523.         'spawnv',
  524.         'spawnve',
  525.         'spawnl',
  526.         'spawnle'])
  527.  
  528. if _exists('spawnvp'):
  529.     
  530.     def spawnlp(mode, file, *args):
  531.         return spawnvp(mode, file, args)
  532.  
  533.     
  534.     def spawnlpe(mode, file, *args):
  535.         env = args[-1]
  536.         return spawnvpe(mode, file, args[:-1], env)
  537.  
  538.     __all__.extend([
  539.         'spawnvp',
  540.         'spawnvpe',
  541.         'spawnlp',
  542.         'spawnlpe'])
  543.  
  544. if _exists('fork'):
  545.     if not _exists('popen2'):
  546.         
  547.         def popen2(cmd, mode = 't', bufsize = -1):
  548.             import popen2
  549.             (stdout, stdin) = popen2.popen2(cmd, bufsize)
  550.             return (stdin, stdout)
  551.  
  552.         __all__.append('popen2')
  553.     
  554.     if not _exists('popen3'):
  555.         
  556.         def popen3(cmd, mode = 't', bufsize = -1):
  557.             import popen2
  558.             (stdout, stdin, stderr) = popen2.popen3(cmd, bufsize)
  559.             return (stdin, stdout, stderr)
  560.  
  561.         __all__.append('popen3')
  562.     
  563.     if not _exists('popen4'):
  564.         
  565.         def popen4(cmd, mode = 't', bufsize = -1):
  566.             import popen2
  567.             (stdout, stdin) = popen2.popen4(cmd, bufsize)
  568.             return (stdin, stdout)
  569.  
  570.         __all__.append('popen4')
  571.     
  572.  
  573. import copy_reg as _copy_reg
  574.  
  575. def _make_stat_result(tup, dict):
  576.     return stat_result(tup, dict)
  577.  
  578.  
  579. def _pickle_stat_result(sr):
  580.     (type, args) = sr.__reduce__()
  581.     return (_make_stat_result, args)
  582.  
  583.  
  584. try:
  585.     _copy_reg.pickle(stat_result, _pickle_stat_result, _make_stat_result)
  586. except NameError:
  587.     pass
  588.  
  589.  
  590. def _make_statvfs_result(tup, dict):
  591.     return statvfs_result(tup, dict)
  592.  
  593.  
  594. def _pickle_statvfs_result(sr):
  595.     (type, args) = sr.__reduce__()
  596.     return (_make_statvfs_result, args)
  597.  
  598.  
  599. try:
  600.     _copy_reg.pickle(statvfs_result, _pickle_statvfs_result, _make_statvfs_result)
  601. except NameError:
  602.     pass
  603.  
  604. if not _exists('urandom'):
  605.     
  606.     def urandom(n):
  607.         
  608.         try:
  609.             _urandomfd = open('/dev/urandom', O_RDONLY)
  610.         except (OSError, IOError):
  611.             raise NotImplementedError('/dev/urandom (or equivalent) not found')
  612.  
  613.         bytes = ''
  614.         while len(bytes) < n:
  615.             bytes += read(_urandomfd, n - len(bytes))
  616.         close(_urandomfd)
  617.         return bytes
  618.  
  619.  
  620.